டைப்ஸ்கிரிப்ட் ஈனம் (Enum) மாற்றுகள்: வலுவான குறியீட்டிற்கான கான்ஸ்ட் அசர்ட்ஷன்ஸ் (Const Assertions) மற்றும் யூனியன் டைப் (Union Types)களை வழிநடத்துதல்

ஜாவாஸ்கிரிப்டின் சக்திவாய்ந்த சூப்பர்செட்டான டைப்ஸ்கிரிப்ட், வலை மேம்பாட்டின் டைனமிக் உலகிற்கு ஸ்டேடிக் டைப்பிங்கை கொண்டு வருகிறது. அதன் பல அம்சங்களில், பெயரிடப்பட்ட மாறிலிகளின் தொகுப்பை வரையறுக்க enum முக்கிய சொல் நீண்ட காலமாக பயன்படுத்தப்படுகிறது. ஈனம்கள் தொடர்புடைய மதிப்புகளின் நிலையான தொகுப்பைக் குறிக்க ஒரு தெளிவான வழியை வழங்குகின்றன, வாசிப்புத்திறன் மற்றும் டைப் பாதுகாப்பை மேம்படுத்துகின்றன.

இருப்பினும், டைப்ஸ்கிரிப்ட் சுற்றுச்சூழல் முதிர்ச்சியடைந்து, திட்டங்கள் சிக்கலான மற்றும் பெரிய அளவில் வளரும்போது, உலகளாவிய டெவலப்பர்கள் ஈனம்களின் பாரம்பரிய பயன்பாட்டை கேள்விக்குள்ளாக்கி வருகின்றனர். எளிய நிகழ்வுகளுக்கு நேரடியானதாக இருந்தாலும், ஈனம்கள் சில நடத்தைகளையும் ரன்டைம் பண்புகளையும் அறிமுகப்படுத்துகின்றன, அவை சில சமயங்களில் எதிர்பாராத சிக்கல்களை ஏற்படுத்தலாம், தொகுப்பு அளவை (bundle size) பாதிக்கலாம் அல்லது ட்ரீ-ஷேக்கிங் (tree-shaking) மேம்பாடுகளை சிக்கலாக்கலாம். இது பரவலான மாற்றுகளை ஆராய வழிவகுத்துள்ளது.

இந்த விரிவான வழிகாட்டி டைப்ஸ்கிரிப்ட் ஈனம்களுக்கு இரண்டு முக்கிய மற்றும் மிகவும் பயனுள்ள மாற்றுகளை ஆழமாக ஆராய்கிறது: ஸ்ட்ரிங்/நியூமரிக் லிட்டரல்ஸ் கொண்ட யூனியன் டைப்கள் மற்றும் கான்ஸ்ட் அசர்ட்ஷன்ஸ் (as const). அவற்றின் வழிமுறைகள், நடைமுறைப் பயன்பாடுகள், நன்மைகள் மற்றும் வர்த்தக பரிமாற்றங்களை (trade-offs) நாங்கள் ஆராய்வோம், உங்கள் திட்டங்களின் அளவு அல்லது அவற்றில் பணிபுரியும் உலகளாவிய குழுவைப் பொருட்படுத்தாமல், தகவலறிந்த வடிவமைப்பு முடிவுகளை எடுக்க உங்களுக்கு அறிவை வழங்குவோம். மிகவும் வலுவான, பராமரிக்கக்கூடிய மற்றும் திறமையான டைப்ஸ்கிரிப்ட் குறியீட்டை எழுத உங்களுக்கு அதிகாரம் அளிப்பதே எங்கள் குறிக்கோள்.

டைப்ஸ்கிரிப்ட் ஈனம்: ஒரு விரைவான மறுபார்வை

மாற்றுகளைப் பற்றி ஆராய்வதற்கு முன், பாரம்பரிய டைப்ஸ்கிரிப்ட் enum பற்றி சுருக்கமாகப் பார்ப்போம். ஈனம்கள் டெவலப்பர்களை பெயரிடப்பட்ட மாறிலிகளின் தொகுப்பை வரையறுக்க அனுமதிக்கின்றன, குறியீட்டை மிகவும் வாசிக்கக்கூடியதாக ஆக்குகின்றன மற்றும் "மேஜிக் ஸ்ட்ரிங்குகள்" அல்லது "மேஜிக் எண்கள்" ஒரு அப்ளிகேஷன் முழுவதும் சிதறடிக்கப்படுவதைத் தடுக்கின்றன. அவை இரண்டு முதன்மை வடிவங்களில் வருகின்றன: நியூமரிக் மற்றும் ஸ்ட்ரிங் ஈனம்கள்.

நியூமரிக் ஈனம்கள்

இயல்புநிலையாக, டைப்ஸ்கிரிப்ட் ஈனம்கள் நியூமரிக் ஆகும். முதல் உறுப்பினர் 0 உடன் தொடங்கப்படுகிறது, மேலும் ஒவ்வொரு அடுத்த உறுப்பினரும் தானாகவே அதிகரிக்கப்படுகிறது.

            enum Direction {
  Up,
  Down,
  Left,
  Right,
}

let currentDirection: Direction = Direction.Up;
console.log(currentDirection); // Outputs: 0
console.log(Direction.Left);    // Outputs: 2

            

              
                Copy
              
            
          

நீங்கள் நியூமரிக் ஈனம் உறுப்பினர்களை கைமுறையாகவும் தொடங்கலாம்:

            enum StatusCode {
  Success = 200,
  NotFound = 404,
  ServerError = 500,
}

let status: StatusCode = StatusCode.NotFound;
console.log(status); // Outputs: 404

            

              
                Copy
              
            
          

நியூமரிக் ஈனம்களின் ஒரு தனித்துவமான அம்சம் ரிவர்ஸ் மேப்பிங் ஆகும். ரன்டைமில், ஒரு நியூமரிக் ஈனம் ஒரு ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்டாக தொகுக்கப்படுகிறது, இது பெயர்களை மதிப்புகளுக்கும், மதிப்புகளை மீண்டும் பெயர்களுக்கும் மேப் செய்கிறது.

            enum UserRole {
  Admin = 1,
  Editor,
  Viewer,
}

console.log(UserRole[1]); // Outputs: "Admin"
console.log(UserRole.Editor); // Outputs: 2
console.log(UserRole[2]); // Outputs: "Editor"

/*
Compiles to JavaScript:
var UserRole;
(function (UserRole) {
    UserRole[UserRole["Admin"] = 1] = "Admin";
    UserRole[UserRole["Editor"] = 2] = "Editor";
    UserRole[UserRole["Viewer"] = 3] = "Viewer";
})(UserRole || (UserRole = {}));
*/

            

              
                Copy
              
            
          

ஸ்ட்ரிங் ஈனம்கள்

ஸ்ட்ரிங் ஈனம்கள் பெரும்பாலும் ரன்டைமில் அவற்றின் வாசிப்புத்திறனுக்காக விரும்பப்படுகின்றன, ஏனெனில் அவை தானாக அதிகரிக்கும் எண்களை நம்புவதில்லை. ஒவ்வொரு உறுப்பினரும் ஒரு ஸ்ட்ரிங் லிட்டரலுடன் தொடங்கப்பட வேண்டும்.

            enum UserPermission {
  Read = "READ_PERMISSION",
  Write = "WRITE_PERMISSION",
  Delete = "DELETE_PERMISSION",
}

let permission: UserPermission = UserPermission.Write;
console.log(permission); // Outputs: "WRITE_PERMISSION"

            

              
                Copy
              
            
          

ஸ்ட்ரிங் ஈனம்கள் ஒரு ரிவர்ஸ் மேப்பிங்கை பெறுவதில்லை, இது பொதுவாக எதிர்பாராத ரன்டைம் நடத்தையைத் தவிர்ப்பதற்கும், உருவாக்கப்பட்ட ஜாவாஸ்கிரிப்ட் வெளியீட்டைக் குறைப்பதற்கும் ஒரு நல்ல விஷயம்.

ஈனம்களின் முக்கிய கருத்தாய்வுகள் மற்றும் சாத்தியமான சிக்கல்கள்

ஈனம்கள் வசதியை வழங்கினாலும், அவை கவனமாக பரிசீலனை செய்ய வேண்டிய சில பண்புகளைக் கொண்டுள்ளன:

• ரன்டைம் ஆப்ஜெக்ட்கள்: நியூமரிக் மற்றும் ஸ்ட்ரிங் ஈனம்கள் இரண்டும் ரன்டைமில் ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்களை உருவாக்குகின்றன. இதன் பொருள், நீங்கள் டைப்-செக்கிங்கிற்கு மட்டுமே அவற்றைப் பயன்படுத்தினாலும், அவை உங்கள் அப்ளிகேஷனின் தொகுப்பு அளவிற்கு (bundle size) பங்களிக்கின்றன. சிறிய திட்டங்களுக்கு, இது முக்கியமற்றதாக இருக்கலாம், ஆனால் பல ஈனம்கள் கொண்ட பெரிய அளவிலான அப்ளிகேஷன்களில், இது அதிகமாகலாம்.
• ட்ரீ-ஷேக்கிங் இல்லாமை: ஈனம்கள் ரன்டைம் ஆப்ஜெக்ட்கள் என்பதால், அவை வெப் பேக் (Webpack) அல்லது ரோல் அப் (Rollup) போன்ற நவீன பண்டலர்களால் (bundlers) திறம்பட ட்ரீ-ஷேக் செய்யப்படுவதில்லை. நீங்கள் ஒரு ஈனத்தை வரையறுத்து, அதன் ஒன்று அல்லது இரண்டு உறுப்பினர்களை மட்டுமே பயன்படுத்தினால், முழு ஈனம் ஆப்ஜெக்ட்டும் உங்கள் இறுதி தொகுப்பில் சேர்க்கப்படலாம். இது தேவையற்ற பெரிய கோப்பு அளவுகளுக்கு வழிவகுக்கும்.
• ரிவர்ஸ் மேப்பிங் (நியூமரிக் ஈனம்கள்): நியூமரிக் ஈனம்களின் ரிவர்ஸ் மேப்பிங் அம்சம், சில சமயங்களில் பயனுள்ளதாக இருந்தாலும், குழப்பம் மற்றும் எதிர்பாராத நடத்தைக்கான ஆதாரமாகவும் இருக்கலாம். இது ஜாவாஸ்கிரிப்ட் வெளியீட்டில் கூடுதல் குறியீட்டைச் சேர்க்கிறது மற்றும் விரும்பிய செயல்பாடாக எப்போதும் இருக்காது. உதாரணமாக, நியூமரிக் ஈனம்களை சீரியலைஸ் செய்வது சில சமயங்களில் எண்ணை மட்டுமே சேமிக்க வழிவகுக்கும், இது ஒரு ஸ்ட்ரிங்கைப் போல விளக்கமாக இருக்காது.
• டிரான்ஸ்பிலேஷன் ஓவர்ஹெட்: ஈனம்களை ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்களாகத் தொகுப்பது, மாறிலிகளை வரையறுப்பதை விட பில்ட் செயல்பாட்டிற்கு ஒரு சிறிய ஓவர்ஹெட்டை சேர்க்கிறது.
• வரையறுக்கப்பட்ட மறுசெயல்பாடு (Iteration): ஈனம் மதிப்புகளை நேரடியாக மறுசெயல்பாடு செய்வது முக்கியமற்றதாக இருக்கலாம், குறிப்பாக ரிவர்ஸ் மேப்பிங் காரணமாக நியூமரிக் ஈனம்களுடன். விரும்பிய மதிப்புகளைப் பெற நீங்கள் பெரும்பாலும் உதவி செயல்பாடுகளை அல்லது குறிப்பிட்ட லூப்களைப் பயன்படுத்த வேண்டும்.

இந்த புள்ளிகள், பல உலகளாவிய மேம்பாட்டுக் குழுக்கள், குறிப்பாக செயல்திறன் மற்றும் தொகுப்பு அளவை (bundle size) மையமாகக் கொண்ட குழுக்கள், ரன்டைம் அடிச்சுவடு அல்லது பிற சிக்கல்கள் இல்லாமல் ஒத்த டைப் பாதுகாப்பை வழங்கும் மாற்றுகளை ஏன் தேடுகின்றன என்பதைக் காட்டுகிறது.

மாற்று 1: லிட்டரல்ஸ் கொண்ட யூனியன் டைப்கள்

டைப்ஸ்கிரிப்டில் ஈனம்களுக்கு மிகவும் நேரடியான மற்றும் சக்திவாய்ந்த மாற்றுகளில் ஒன்று ஸ்ட்ரிங் அல்லது நியூமரிக் லிட்டரல்ஸ் கொண்ட யூனியன் டைப்களின் பயன்பாடு ஆகும். இந்த அணுகுமுறை டைப்ஸ்கிரிப்டின் வலுவான டைப் அமைப்பைப் பயன்படுத்தி, ரன்டைமில் எந்த புதிய கட்டமைப்புகளையும் அறிமுகப்படுத்தாமல், கம்பைல்-டைமில் குறிப்பிட்ட, அனுமதிக்கப்பட்ட மதிப்புகளின் தொகுப்பை வரையறுக்கிறது.

யூனியன் டைப்கள் என்றால் என்ன?

ஒரு யூனியன் டைப் என்பது பல டைப்களில் ஒன்றைக் கொண்டிருக்கக்கூடிய ஒரு மதிப்பைக் குறிக்கிறது. உதாரணமாக, string | number என்பது ஒரு வேரியபிள் ஸ்ட்ரிங் அல்லது நம்பரை வைத்திருக்க முடியும் என்று அர்த்தம். லிட்டரல் டைப்களுடன் (எ.கா., "success", 404) இணைக்கும்போது, நீங்கள் முன்னரே வரையறுக்கப்பட்ட மதிப்புகளின் குறிப்பிட்ட தொகுப்பை மட்டுமே வைத்திருக்கக்கூடிய ஒரு டைப்பை வரையறுக்கலாம்.

நடைமுறை உதாரணம்: யூனியன் டைப்களுடன் ஸ்டேட்டஸ்களை வரையறுத்தல்

ஒரு டேட்டா ப்ராசசிங் வேலை அல்லது ஒரு பயனரின் கணக்கிற்கான சாத்தியமான ஸ்டேட்டஸ்களின் தொகுப்பை வரையறுக்கும் ஒரு பொதுவான சூழ்நிலையைக் கருத்தில் கொள்வோம். யூனியன் டைப்களுடன், இது சுத்தமாகவும் சுருக்கமாகவும் தெரிகிறது:

            type JobStatus = "PENDING" | "IN_PROGRESS" | "COMPLETED" | "FAILED";

function processJob(status: JobStatus): void {
  if (status === "COMPLETED") {
    console.log("Job finished successfully.");
  } else if (status === "FAILED") {
    console.log("Job encountered an error.");
  } else {
    console.log(`Job is currently ${status}.`);
  }
}

let currentJobStatus: JobStatus = "IN_PROGRESS";
processJob(currentJobStatus);

// This would result in a compile-time error:
// let invalidStatus: JobStatus = "CANCELLED"; // Error: Type '"CANCELLED"' is not assignable to type 'JobStatus'.

            

              
                Copy
              
            
          

நியூமரிக் மதிப்புகளுக்கு, முறை ஒரே மாதிரியானது:

            type HttpCode = 200 | 400 | 404 | 500;

function handleResponse(code: HttpCode): void {
  if (code === 200) {
    console.log("Operation successful.");
  } else if (code === 404) {
    console.log("Resource not found.");
  }
}

let responseStatus: HttpCode = 200;
handleResponse(responseStatus);

            

              
                Copy
              
            
          

இங்கே நாம் ஒரு type மாற்றுப் பெயரை எவ்வாறு வரையறுக்கிறோம் என்பதைக் கவனியுங்கள். இது முற்றிலும் கம்பைல்-டைம் கட்டமைப்பாகும். ஜாவாஸ்கிரிப்டுக்குத் தொகுக்கப்படும்போது, JobStatus வெறுமனே மறைந்துவிடும், மேலும் லிட்டரல் ஸ்ட்ரிங்குகள்/எண்கள் நேரடியாகப் பயன்படுத்தப்படுகின்றன.

லிட்டரல்ஸ் கொண்ட யூனியன் டைப்களின் நன்மைகள்

இந்த அணுகுமுறை பல கவர்ச்சிகரமான நன்மைகளை வழங்குகிறது:

• முற்றிலும் கம்பைல்-டைம்: தொகுப்பின் போது யூனியன் டைப்கள் முற்றிலும் அழிக்கப்படுகின்றன. அவை ரன்டைமில் எந்த ஜாவாஸ்கிரிப்ட் குறியீட்டையும் உருவாக்குவதில்லை, இது சிறிய தொகுப்பு அளவுகள் மற்றும் வேகமான அப்ளிகேஷன் தொடக்க நேரங்களுக்கு வழிவகுக்கிறது. இது செயல்திறன்-முக்கியமான அப்ளிகேஷன்களுக்கும், ஒவ்வொரு கிலோபைட்டும் கணக்கில் வரும் உலகளவில் பயன்படுத்தப்படும் அப்ளிகேஷன்களுக்கும் ஒரு குறிப்பிடத்தக்க நன்மை.
• சிறந்த டைப் பாதுகாப்பு: டைப்ஸ்கிரிப்ட் வரையறுக்கப்பட்ட லிட்டரல் டைப்களுக்கு எதிராக அசைன்மென்ட்களை கடுமையாகச் சரிபார்த்து, சரியான மதிப்புகள் மட்டுமே பயன்படுத்தப்படுவதற்கான வலுவான உத்தரவாதங்களை வழங்குகிறது. இது தட்டச்சு பிழைகள் அல்லது தவறான மதிப்புகளுடன் தொடர்புடைய பொதுவான பிழைகளைத் தடுக்கிறது.
• சிறந்த ட்ரீ-ஷேக்கிங்: ரன்டைம் ஆப்ஜெக்ட் இல்லாததால், யூனியன் டைப்கள் உள்ளார்ந்த ட்ரீ-ஷேக்கிங்கை ஆதரிக்கின்றன. உங்கள் பண்டலர் நீங்கள் பயன்படுத்தும் உண்மையான ஸ்ட்ரிங் அல்லது நியூமரிக் லிட்டரல்களை மட்டுமே சேர்க்கிறது, ஒரு முழு ஆப்ஜெக்ட்டை அல்ல.
• வாசிப்புத்திறன்: ஒரு நிலையான, எளிய, தனித்துவமான மதிப்புகளின் தொகுப்பிற்கு, டைப் வரையறை பெரும்பாலும் மிகத் தெளிவாகவும் புரிந்துகொள்ள எளிதாகவும் இருக்கும்.
• எளிமை: புதிய மொழி கட்டமைப்புகள் அல்லது சிக்கலான தொகுப்பு கலைப்பொருட்கள் எதுவும் அறிமுகப்படுத்தப்படவில்லை. இது அடிப்படை டைப்ஸ்கிரிப்ட் டைப் அம்சங்களைப் பயன்படுத்துகிறது.
• நேரடி மதிப்பு அணுகல்: நீங்கள் நேரடியாக ஸ்ட்ரிங் அல்லது எண் மதிப்புகளுடன் பணிபுரிகிறீர்கள், இது சீரியலைசேஷன் மற்றும் டிசீரியலைசேஷனை எளிதாக்குகிறது, குறிப்பாக குறிப்பிட்ட ஸ்ட்ரிங் அடையாளங்காட்டிகளை எதிர்பார்க்கும் APIகள் அல்லது டேட்டாபேஸ்களுடன் தொடர்பு கொள்ளும்போது.

லிட்டரல்ஸ் கொண்ட யூனியன் டைப்களின் குறைபாடுகள்

சக்திவாய்ந்ததாக இருந்தாலும், யூனியன் டைப்களுக்கும் சில வரம்புகள் உள்ளன:

• தொடர்புடைய டேட்டாவிற்கான மறுசெயல்பாடு: ஒவ்வொரு "ஈனம்" உறுப்பினருடனும் கூடுதல் டேட்டா அல்லது மெட்டாடேட்டாவை (எ.கா., ஒரு டிஸ்ப்ளே லேபிள், ஒரு ஐகான், ஒரு கலர்) தொடர்புபடுத்த வேண்டும் என்றால், யூனியன் டைப் வரையறையில் நேரடியாக இதைச் செய்ய முடியாது. உங்களுக்கு பொதுவாக ஒரு தனி மேப்பிங் ஆப்ஜெக்ட் தேவைப்படும்.
• அனைத்து மதிப்புகளின் நேரடி மறுசெயல்பாடு இல்லை: ரன்டைமில் ஒரு யூனியன் டைப்பிலிருந்து அனைத்து சாத்தியமான மதிப்புகளின் அர்ரேயைப் பெற உள்ளமைக்கப்பட்ட வழி இல்லை. உதாரணமாக, ["PENDING", "IN_PROGRESS", "COMPLETED", "FAILED"] என்பதை JobStatus இலிருந்து நேரடியாக எளிதாகப் பெற முடியாது. UI இல் (எ.கா., ஒரு ட்ராப்டவுன் மெனு) அவற்றைக் காட்ட வேண்டும் என்றால், இது பெரும்பாலும் மதிப்புகளின் தனி அர்ரேயைப் பராமரிக்க வேண்டிய அவசியத்தை ஏற்படுத்துகிறது.
• குறைவான மையப்படுத்தப்பட்ட: மதிப்புகளின் தொகுப்பு ஒரு டைப்பாகவும், ரன்டைம் மதிப்புகளின் அர்ரேயாகவும் தேவைப்பட்டால், நீங்கள் பட்டியலை இரண்டு முறை (ஒரு முறை ஒரு டைப்பாக, ஒரு முறை ஒரு ரன்டைம் அர்ரேயாக) வரையறுக்க வேண்டியிருக்கலாம், இது ஒத்திசைவின்மைக்கான வாய்ப்பை அறிமுகப்படுத்தலாம்.

இந்த குறைபாடுகள் இருந்தபோதிலும், பல சூழ்நிலைகளுக்கு, யூனியன் டைப்கள் ஒரு சுத்தமான, செயல்திறன் மிக்க மற்றும் டைப்-பாதுகாப்பான தீர்வை வழங்குகின்றன, இது நவீன ஜாவாஸ்கிரிப்ட் மேம்பாட்டு நடைமுறைகளுடன் இணைகிறது.

மாற்று 2: கான்ஸ்ட் அசர்ட்ஷன்ஸ் (as const)

டைப்ஸ்கிரிப்ட் 3.4 இல் அறிமுகப்படுத்தப்பட்ட as const அசர்ட்ஷன், ஈனம்களுக்கு ஒரு சிறந்த மாற்றாக இருக்கும் மற்றொரு நம்பமுடியாத சக்திவாய்ந்த கருவியாகும், குறிப்பாக உங்களுக்கு ஒரு ரன்டைம் ஆப்ஜெக்ட் மற்றும் வலுவான டைப் இன்ஃபெரன்ஸ் (type inference) தேவைப்படும்போது. இது டைப்ஸ்கிரிப்டை லிட்டரல் எக்ஸ்பிரஷன்களுக்கு மிகக் குறுகிய சாத்தியமான டைப்பை ஊகிக்க அனுமதிக்கிறது.

கான்ஸ்ட் அசர்ட்ஷன்ஸ் என்றால் என்ன?

ஒரு வேரியபிள், ஒரு அர்ரே அல்லது ஒரு ஆப்ஜெக்ட் லிட்டரலுக்கு நீங்கள் as const ஐப் பயன்படுத்தும்போது, டைப்ஸ்கிரிப்ட் அந்த லிட்டரலில் உள்ள அனைத்து ப்ராபர்ட்டிகளையும் readonly ஆக கருதுகிறது மற்றும் பரந்த டைப்களுக்குப் பதிலாக அவற்றின் லிட்டரல் டைப்களை (எ.கா., string க்கு பதிலாக "foo", number க்கு பதிலாக 123) ஊகிக்கிறது. இது ரன்டைம் டேட்டா கட்டமைப்புகளிலிருந்து மிகவும் குறிப்பிட்ட யூனியன் டைப்களைப் பெற உதவுகிறது.

நடைமுறை உதாரணம்: as const உடன் ஒரு "சூடோ-ஈனம்" ஆப்ஜெக்ட்டை உருவாக்குதல்

எங்கள் வேலை நிலை உதாரணத்திற்கு மீண்டும் வருவோம். as const உடன், எங்கள் ஸ்டேட்டஸ்களுக்கான ஒற்றை மூல உண்மையை வரையறுக்கலாம், இது ஒரு ரன்டைம் ஆப்ஜெக்ட்டாகவும் மற்றும் டைப் வரையறைகளுக்கான அடிப்படையாகவும் செயல்படுகிறது.

            const JobStatuses = {
  PENDING: "PENDING",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
} as const;

// JobStatuses.PENDING is now inferred as type "PENDING" (not just string)
// JobStatuses is inferred as type {
//   readonly PENDING: "PENDING";
//   readonly IN_PROGRESS: "IN_PROGRESS";
//   readonly COMPLETED: "COMPLETED";
//   readonly FAILED: "FAILED";
// }

            

              
                Copy
              
            
          

இந்த கட்டத்தில், JobStatuses ஒரு சாதாரண ஈனம் போலவே, ரன்டைமில் ஒரு ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் ஆகும். இருப்பினும், அதன் டைப் இன்ஃபெரன்ஸ் (type inference) மிகவும் துல்லியமானது.

யூனியன் டைப்களுக்காக typeof மற்றும் keyof உடன் இணைத்தல்

as const ஐ டைப்ஸ்கிரிப்டின் typeof மற்றும் keyof ஆபரேட்டர்களுடன் இணைத்து, ஆப்ஜெக்ட்டின் மதிப்புகள் அல்லது கீகளிலிருந்து ஒரு யூனியன் டைப்பை நாம் பெறும்போது உண்மையான சக்தி வெளிப்படுகிறது.

            const JobStatuses = {
  PENDING: "PENDING",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
} as const;

// Type representing the keys (e.g., "PENDING" | "IN_PROGRESS" | ...)
type JobStatusKeys = keyof typeof JobStatuses;

// Type representing the values (e.g., "PENDING" | "IN_PROGRESS" | ...)
type JobStatusValues = typeof JobStatuses[keyof typeof JobStatuses];

function processJobWithConstAssertion(status: JobStatusValues): void {
  if (status === JobStatuses.COMPLETED) {
    console.log("Job finished successfully.");
  } else if (status === JobStatuses.FAILED) {
    console.log("Job encountered an error.");
  } else {
    console.log(`Job is currently ${status}.`);
  }
}

let currentJobStatusFromObject: JobStatusValues = JobStatuses.IN_PROGRESS;
processJobWithConstAssertion(currentJobStatusFromObject);

// This would result in a compile-time error:
// let invalidStatusFromObject: JobStatusValues = "CANCELLED"; // Error!

            

              
                Copy
              
            
          

இந்த முறை இரு உலகங்களிலும் சிறந்ததை வழங்குகிறது: மறுசெயல்பாடு அல்லது நேரடி ப்ராபர்ட்டி அணுகலுக்கான ஒரு ரன்டைம் ஆப்ஜெக்ட், மற்றும் கடுமையான டைப் சோதனைகளுக்கான ஒரு கம்பைல்-டைம் யூனியன் டைப்.

பெறப்பட்ட யூனியன் டைப்களுடன் கான்ஸ்ட் அசர்ட்ஷன்களின் நன்மைகள்

• உண்மையின் ஒற்றை ஆதாரம்: உங்கள் மாறிலிகளை ஒரு முறை ஒரு சாதாரண ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்டில் வரையறுத்து, அதிலிருந்து ரன்டைம் அணுகல் மற்றும் கம்பைல்-டைம் டைப்கள் இரண்டையும் பெறுகிறீர்கள். இது நகலெடுப்பைக் கணிசமாகக் குறைக்கிறது மற்றும் பல்வேறு மேம்பாட்டுக் குழுக்களிடையே பராமரிப்புத்திறனை மேம்படுத்துகிறது.
• டைப் பாதுகாப்பு: தூய யூனியன் டைப்களைப் போலவே, நீங்கள் சிறந்த டைப் பாதுகாப்பைப் பெறுகிறீர்கள், முன்னரே வரையறுக்கப்பட்ட மதிப்புகள் மட்டுமே பயன்படுத்தப்படுவதை உறுதி செய்கிறது.
• ரன்டைமில் மறுசெயல்பாடு: JobStatuses ஒரு சாதாரண ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் என்பதால், Object.keys(), Object.values() அல்லது Object.entries() போன்ற நிலையான ஜாவாஸ்கிரிப்ட் முறைகளைப் பயன்படுத்தி அதன் கீகள் அல்லது மதிப்புகளை எளிதாக மறுசெயல்பாடு செய்யலாம். டைனமிக் UI களுக்கு (எ.கா., ட்ராப்டவுன்களை நிரப்புதல்) அல்லது லாகிங்கிற்கு இது விலைமதிப்பற்றது.
• தொடர்புடைய டேட்டா: இந்த முறை ஒவ்வொரு "ஈனம்" உறுப்பினருடனும் கூடுதல் டேட்டாவை இணைக்க இயற்கையாகவே ஆதரவளிக்கிறது.
• சிறந்த ட்ரீ-ஷேக்கிங் சாத்தியம் (ஈனம்களுடன் ஒப்பிடுகையில்): as const ஒரு ரன்டைம் ஆப்ஜெக்ட்டை உருவாக்கினாலும், இது ஒரு நிலையான ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் ஆகும். டைப்ஸ்கிரிப்டின் ஈனம் தொகுப்பு வெளியீட்டை விட, நவீன பண்டலர்கள் பொதுவாக பயன்படுத்தப்படாத ப்ராபர்ட்டிகள் அல்லது குறிப்பு செய்யப்படாவிட்டால் முழு ஆப்ஜெக்ட்டுகளையும் ட்ரீ-ஷேக் செய்வதில் மிகவும் பயனுள்ளதாக இருக்கும். இருப்பினும், ஆப்ஜெக்ட் பெரியதாக இருந்தால் மற்றும் ஒரு சில ப்ராபர்ட்டிகள் மட்டுமே பயன்படுத்தப்பட்டால், முழு ஆப்ஜெக்ட்டும் இன்னும் சேர்க்கப்படலாம், அது மாடூல்களின் எல்லைகளுக்கு அப்பால் நுண்துகள் ட்ரீ-ஷேக்கிங்கைத் தடுக்கும் வகையில் இறக்குமதி செய்யப்பட்டால்.
• நெகிழ்வுத்தன்மை: நீங்கள் ஸ்ட்ரிங்குகள் அல்லது எண்கள் மட்டுமல்லாமல், தேவைப்பட்டால் மிகவும் சிக்கலான ஆப்ஜெக்ட்களையும் வரையறுக்கலாம், இது ஒரு மிகவும் நெகிழ்வான முறையாகும்.

            const FileOperations = {
  UPLOAD: {
    label: "Upload File",
    icon: "upload-icon.svg",
    permission: "can_upload"
  },
  DOWNLOAD: {
    label: "Download File",
    icon: "download-icon.svg",
    permission: "can_download"
  },
  DELETE: {
    label: "Delete File",
    icon: "delete-icon.svg",
    permission: "can_delete"
  },
} as const;

type FileOperationType = keyof typeof FileOperations; // "UPLOAD" | "DOWNLOAD" | "DELETE"
type FileOperationDetail = typeof FileOperations[keyof typeof FileOperations]; // { label: string; icon: string; permission: string; }

function performOperation(opType: FileOperationType) {
  const details = FileOperations[opType];
  console.log(`Performing: ${details.label} (Permission: ${details.permission})`);
}

performOperation("UPLOAD");

            

              
                Copy
              
            
          

கான்ஸ்ட் அசர்ட்ஷன்களின் குறைபாடுகள்

• ரன்டைம் ஆப்ஜெக்ட் இருப்பு: தூய யூனியன் டைப்களைப் போலல்லாமல், இந்த அணுகுமுறை இன்னும் ரன்டைமில் ஒரு ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்டை உருவாக்குகிறது. இது ஒரு நிலையான ஆப்ஜெக்ட் மற்றும் ஈனம்களை விட ட்ரீ-ஷேக்கிங்கிற்கு அடிக்கடி சிறந்தது என்றாலும், அது முற்றிலும் அழிக்கப்படுவதில்லை.
• சற்று அதிக விரிவான டைப் வரையறை: யூனியன் டைப்பை (keyof typeof ... அல்லது typeof ...[keyof typeof ...]) பெறுவதற்கு, யூனியன் டைப்பிற்கான லிட்டரல்களை பட்டியலிடுவதை விட சற்று அதிக சின்டாக்ஸ் தேவைப்படுகிறது.
• தவறாகப் பயன்படுத்துவதற்கான சாத்தியம்: கவனமாகப் பயன்படுத்தப்படாவிட்டால், ஒரு பெரிய as const ஆப்ஜெக்ட் அதன் உள்ளடக்கங்கள் மாடூல் எல்லைகளுக்கு அப்பால் திறம்பட ட்ரீ-ஷேக் செய்யப்படாவிட்டால், தொகுப்பு அளவிற்கு கணிசமாக பங்களிக்கலாம்.

வலுவான கம்பைல்-டைம் டைப் சோதனை மற்றும் மறுசெயல்பாடு செய்யக்கூடிய அல்லது தொடர்புடைய டேட்டாவை வழங்கும் மதிப்புகளின் ரன்டைம் சேகரிப்பு இரண்டும் தேவைப்படும் சூழ்நிலைகளில், உலகளவில் டைப்ஸ்கிரிப்ட் டெவலப்பர்களிடையே as const பெரும்பாலும் விரும்பப்படும் தேர்வாகும்.

மாற்றுகளை ஒப்பிடுதல்: எப்போது எதைப் பயன்படுத்த வேண்டும்?

யூனியன் டைப்களுக்கும் கான்ஸ்ட் அசர்ட்ஷன்களுக்கும் இடையே தேர்வு செய்வது, ரன்டைம் இருப்பு, மறுசெயல்பாடு மற்றும் உங்கள் மாறிலிகளுடன் கூடுதல் டேட்டாவை தொடர்புபடுத்த வேண்டுமா என்பது குறித்த உங்கள் குறிப்பிட்ட தேவைகளைப் பொறுத்தது. முடிவெடுக்கும் காரணிகளைப் பிரித்து பார்ப்போம்.

எளிமை vs. வலுவுறுதி

• யூனியன் டைப்கள்: கம்பைல்-டைமில் தனித்துவமான ஸ்ட்ரிங் அல்லது நியூமரிக் மதிப்புகளின் டைப்-பாதுகாப்பான தொகுப்பு மட்டுமே உங்களுக்குத் தேவைப்படும்போது இறுதி எளிமையை வழங்குகின்றன. அவை மிகவும் லேசான விருப்பம்.
• கான்ஸ்ட் அசர்ட்ஷன்ஸ்: உங்களுக்கு கம்பைல்-டைம் டைப் பாதுகாப்பு மற்றும் குயரி செய்யக்கூடிய, மறுசெயல்பாடு செய்யக்கூடிய அல்லது கூடுதல் மெட்டாடேட்டாவுடன் விரிவாக்கக்கூடிய ஒரு ரன்டைம் ஆப்ஜெக்ட் இரண்டும் தேவைப்படும்போது, மிகவும் வலுவான முறையை வழங்குகின்றன. ஆரம்ப அமைவு சற்று விரிவாக இருந்தாலும், அது அம்சங்களில் பலன் அளிக்கிறது.

ரன்டைம் vs. கம்பைல்-டைம் இருப்பு

• யூனியன் டைப்கள்: முற்றிலும் கம்பைல்-டைம் கட்டமைப்புகள். அவை எந்த ஜாவாஸ்கிரிப்ட் குறியீட்டையும் உருவாக்குவதில்லை. தொகுப்பு அளவைக் குறைப்பது மிக முக்கியமானது மற்றும் மதிப்புகள் ரன்டைமில் ஒரு ஆப்ஜெக்ட்டாக அணுகப்படாமல் போதுமானதாக இருக்கும் அப்ளிகேஷன்களுக்கு இது சிறந்தது.
• கான்ஸ்ட் அசர்ட்ஷன்ஸ்: ரன்டைமில் ஒரு சாதாரண ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்டை உருவாக்குகின்றன. இந்த ஆப்ஜெக்ட் உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டில் அணுகக்கூடியது மற்றும் பயன்படுத்தக்கூடியது. இது தொகுப்பு அளவில் சேர்க்கப்பட்டாலும், டைப்ஸ்கிரிப்ட் ஈனம்களை விட பொதுவாக மிகவும் திறமையானது மற்றும் ட்ரீ-ஷேக்கிங்கிற்கு சிறந்த வேட்பாளர்கள்.

மறுசெயல்பாடு தேவைகள்

• யூனியன் டைப்கள்: ரன்டைமில் அனைத்து சாத்தியமான மதிப்புகளையும் மறுசெயல்பாடு செய்ய நேரடி வழியை வழங்குவதில்லை. நீங்கள் ஒரு ட்ராப்டவுன் மெனுவை நிரப்ப வேண்டும் அல்லது அனைத்து விருப்பங்களையும் காட்ட வேண்டும் என்றால், இந்த மதிப்புகளின் தனி அர்ரேயை வரையறுக்க வேண்டும், இது நகலெடுப்பிற்கு வழிவகுக்கும்.
• கான்ஸ்ட் அசர்ட்ஷன்ஸ்: இங்கே சிறந்து விளங்குகின்றன. நீங்கள் ஒரு நிலையான ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்டுடன் பணிபுரிவதால், Object.keys(), Object.values() அல்லது Object.entries() போன்ற நிலையான ஜாவாஸ்கிரிப்ட் முறைகளைப் பயன்படுத்தி கீகள், மதிப்புகள் அல்லது கீ-மதிப்பு ஜோடிகளின் அர்ரேயை எளிதாகப் பெறலாம். இது டைனமிக் UI களுக்கு அல்லது ரன்டைம் எண்ணிக்கையை (enumeration) தேவைப்படும் எந்த சூழ்நிலைக்கும் அவற்றை சரியானதாக ஆக்குகிறது.

            const PaymentMethods = {
  CREDIT_CARD: "Credit Card",
  PAYPAL: "PayPal",
  BANK_TRANSFER: "Bank Transfer",
} as const;

type PaymentMethodType = keyof typeof PaymentMethods;

// Get all keys (e.g., for internal logic)
const methodKeys = Object.keys(PaymentMethods) as PaymentMethodType[];
console.log(methodKeys); // ["CREDIT_CARD", "PAYPAL", "BANK_TRANSFER"]

// Get all values (e.g., for display in a dropdown)
const methodLabels = Object.values(PaymentMethods);
console.log(methodLabels); // ["Credit Card", "PayPal", "Bank Transfer"]

// Get key-value pairs (e.g., for mapping)
const methodEntries = Object.entries(PaymentMethods);
console.log(methodEntries); // [["CREDIT_CARD", "Credit Card"], ...]

            

              
                Copy
              
            
          

ட்ரீ-ஷேக்கிங் தாக்கங்கள்

• யூனியன் டைப்கள்: உள்ளார்ந்த ட்ரீ-ஷேக்கபிள் ஆகும், ஏனெனில் அவை கம்பைல்-டைம் மட்டுமே.
• கான்ஸ்ட் அசர்ட்ஷன்ஸ்: அவை ஒரு ரன்டைம் ஆப்ஜெக்ட்டை உருவாக்கினாலும், நவீன பண்டலர்கள் டைப்ஸ்கிரிப்ட்டின் உருவாக்கப்பட்ட ஈனம் ஆப்ஜெக்ட்களை விட இந்த ஆப்ஜெக்ட்டின் பயன்படுத்தப்படாத ப்ராபர்ட்டிகளை அடிக்கடி மிகவும் திறம்பட ட்ரீ-ஷேக் செய்ய முடியும். இருப்பினும், முழு ஆப்ஜெக்ட்டும் இறக்குமதி செய்யப்பட்டு குறிப்பு செய்யப்பட்டால், அது சேர்க்கப்படும். கவனமான மாடூல் வடிவமைப்பு உதவும்.

சிறந்த நடைமுறைகள் மற்றும் ஹைப்ரிட் அணுகுமுறைகள்

இது எப்போதும் "இது அல்லது அது" என்ற நிலை அல்ல. பெரும்பாலும், சிறந்த தீர்வு ஒரு ஹைப்ரிட் அணுகுமுறையை உள்ளடக்கியது, குறிப்பாக பெரிய, பன்னாட்டுமயமாக்கப்பட்ட அப்ளிகேஷன்களில்:

• எளிமையான, முற்றிலும் உள் கொடிகள் அல்லது அடையாளங்காட்டிகளுக்கு, மறுசெயல்பாடு செய்யப்பட வேண்டியதில்லை அல்லது தொடர்புடைய டேட்டாவைக் கொண்டிருக்க வேண்டியதில்லை என்றால், யூனியன் டைப்கள் பொதுவாக மிகவும் செயல்திறன் மிக்க மற்றும் சுத்தமான தேர்வாகும்.
• மறுசெயல்பாடு செய்யப்பட வேண்டிய, UI களில் காட்டப்பட வேண்டிய, அல்லது சிறந்த தொடர்புடைய மெட்டாடேட்டாவைக் (லேபிள்கள், ஐகான்கள் அல்லது அனுமதிகள் போன்றவை) கொண்ட மாறிலிகளின் தொகுப்புகளுக்கு, கான்ஸ்ட் அசர்ட்ஷன்ஸ் முறை சிறந்தது.
• வாசிப்புத்திறன் மற்றும் லோக்கலைசேஷனுக்கான ஒருங்கிணைப்பு: பல குழுக்கள் உள் அடையாளங்காட்டிகளுக்கு as const ஐப் பயன்படுத்துகின்றன, பின்னர் தனி சர்வதேசமயமாக்கல் (i18n) அமைப்பிலிருந்து லோக்கலைஸ் செய்யப்பட்ட டிஸ்ப்ளே லேபிள்களைப் பெறுகின்றன.

            // src/constants/order-status.ts
const OrderStatuses = {
  PENDING: "PENDING",
  PROCESSING: "PROCESSING",
  SHIPPED: "SHIPPED",
  DELIVERED: "DELIVERED",
  CANCELLED: "CANCELLED",
} as const;

type OrderStatus = typeof OrderStatuses[keyof typeof OrderStatuses];

export { OrderStatuses, type OrderStatus };

// src/i18n/en.json
{
  "orderStatus": {
    "PENDING": "Pending Confirmation",
    "PROCESSING": "Processing Order",
    "SHIPPED": "Shipped",
    "DELIVERED": "Delivered",
    "CANCELLED": "Cancelled"
  }
}

// src/i18n/locales/es.json
{
  "productCategories": {
    "ELECTRONICS": "Electrónica",
    "APPAREL": "Ropa y Accesorios",
    "HOME_GOODS": "Artículos para el hogar",
    "BOOKS": "Libros"
  }
}

// app/components/OrderStatusDisplay.tsx
import { OrderStatuses, type OrderStatus } from "../features/product/constants";
import { useTranslation } from "react-i18next"; // Example i18n library

interface OrderStatusDisplayProps {
  status: OrderStatus;
}

function OrderStatusDisplay({ status }: OrderStatusDisplayProps) {
  const { t } = useTranslation();
  const displayLabel = t(`orderStatus.${status}`);
  return <span>Status: {displayLabel}</span>;
}

// Usage:
// <OrderStatusDisplay status={OrderStatuses.DELIVERED} />

            

              
                Copy
              
            
          

இந்த ஹைப்ரிட் அணுகுமுறை as const இன் டைப் பாதுகாப்பு மற்றும் ரன்டைம் மறுசெயல்பாட்டைப் பயன்படுத்துகிறது, அதே நேரத்தில் லோக்கலைஸ் செய்யப்பட்ட டிஸ்ப்ளே ஸ்ட்ரிங்குகளை தனித்தனியாகவும் நிர்வகிக்கக்கூடியதாகவும் வைத்திருக்கிறது, இது உலகளாவிய அப்ளிகேஷன்களுக்கான ஒரு முக்கியமான கருத்தாய்வு.

மேம்பட்ட முறைகள் மற்றும் கருத்தாய்வுகள்

அடிப்படை பயன்பாட்டிற்கு அப்பால், யூனியன் டைப்கள் மற்றும் கான்ஸ்ட் அசர்ட்ஷன்ஸ் இரண்டும் குறியீட்டுத் தரத்தையும் பராமரிப்புத்திறனையும் மேலும் மேம்படுத்த மிகவும் அதிநவீன முறைகளில் ஒருங்கிணைக்கப்படலாம்.

யூனியன் டைப்களுடன் டைப் கார்டுகளைப் பயன்படுத்துதல்

யூனியன் டைப்களுடன் பணிபுரியும் போது, குறிப்பாக யூனியன் பல்வேறு டைப்களை (லிட்டரல்கள் மட்டுமல்ல) உள்ளடக்கும்போது, டைப்களைக் குறைக்க டைப் கார்டுகள் அத்தியாவசியமாகின்றன. லிட்டரல் யூனியன் டைப்களுடன், டிஸ்கிரிமினேட்டட் யூனியன்கள் அளவற்ற சக்தியை வழங்குகின்றன.

            type SuccessEvent = { type: "SUCCESS"; data: any; };
type ErrorEvent = { type: "ERROR"; message: string; code: number; };

type SystemEvent = SuccessEvent | ErrorEvent;

function handleSystemEvent(event: SystemEvent) {
  if (event.type === "SUCCESS") {
    console.log("Data received:", event.data);
    // event is now narrowed to SuccessEvent
  } else {
    console.log("Error occurred:", event.message, "Code:", event.code);
    // event is now narrowed to ErrorEvent
  }
}

handleSystemEvent({ type: "SUCCESS", data: { user: "Alice" } });
handleSystemEvent({ type: "ERROR", message: "Network failure", code: 503 });

            

              
                Copy
              
            
          

"டிஸ்கிரிமினேட்டட் யூனியன்கள்" என்று அடிக்கடி அழைக்கப்படும் இந்த முறை, நம்பமுடியாத அளவிற்கு வலுவானது மற்றும் டைப்-பாதுகாப்பானது, ஒரு பொதுவான லிட்டரல் ப்ராபர்ட்டியை (டிஸ்கிரிமினேட்டர்) அடிப்படையாகக் கொண்டு உங்கள் டேட்டா கட்டமைப்பைப் பற்றிய கம்பைல்-டைம் உத்தரவாதங்களை வழங்குகிறது.

Object.values() உடன் as const மற்றும் டைப் அசர்ட்ஷன்ஸ்

as const முறையைப் பயன்படுத்தும்போது, Object.values() மிகவும் பயனுள்ளதாக இருக்கும். இருப்பினும், Object.values() க்கான டைப்ஸ்கிரிப்டின் இயல்புநிலை இன்ஃபெரன்ஸ் (inference) விரும்பியதை விட பரந்ததாக இருக்கலாம் (எ.கா., லிட்டரல்களின் ஒரு குறிப்பிட்ட யூனியனுக்குப் பதிலாக string[]). கடுமையான தன்மைக்கு உங்களுக்கு ஒரு டைப் அசர்ட்ஷன் தேவைப்படலாம்.

            const Statuses = {
  ACTIVE: "Active",
  INACTIVE: "Inactive",
  PENDING: "Pending",
} as const;

type StatusValue = typeof Statuses[keyof typeof Statuses]; // "Active" | "Inactive" | "Pending"

// Object.values(Statuses) is inferred as (string | "Active" | "Inactive" | "Pending")[]
// We can assert it more narrowly if needed:
const allStatusValues: StatusValue[] = Object.values(Statuses);

console.log(allStatusValues); // ["Active", "Inactive", "Pending"]

// For a dropdown, you might pair values with labels if they differ
const statusOptions = Object.entries(Statuses).map(([key, value]) => ({
  value: key, // Use the key as the actual identifier
  label: value // Use the value as the display label
}));
console.log(statusOptions);
/*
[
  { value: "ACTIVE", label: "Active" },
  { value: "INACTIVE", label: "Inactive" },
  { value: "PENDING", label: "Pending" }
]
*/

            

              
                Copy
              
            
          

இது UI கூறுகளுக்கு ஏற்ற வலுவான டைப் செய்யப்பட்ட மதிப்புகளின் அர்ரேயை எவ்வாறு பெறுவது என்பதைக் காட்டுகிறது, அதே நேரத்தில் லிட்டரல் டைப்களைப் பராமரிக்கிறது.

சர்வதேசமயமாக்கல் (i18n) மற்றும் லோக்கலைஸ் செய்யப்பட்ட லேபிள்கள்

உலகளாவிய அப்ளிகேஷன்களுக்கு, லோக்கலைஸ் செய்யப்பட்ட ஸ்ட்ரிங்குகளை நிர்வகிப்பது மிக முக்கியம். டைப்ஸ்கிரிப்ட் ஈனம்கள் மற்றும் அவற்றின் மாற்றுகள் உள் அடையாளங்காட்டிகளை வழங்கினாலும், காட்சி லேபிள்கள் பெரும்பாலும் i18n க்காக பிரிக்கப்பட வேண்டும். as const முறை i18n அமைப்புகளுக்கு அழகாக துணையாக இருக்கிறது.

உங்கள் உள், மாறாத அடையாளங்காட்டிகளை as const ஐப் பயன்படுத்தி வரையறுக்கிறீர்கள். இந்த அடையாளங்காட்டிகள் அனைத்து லோகேல்களிலும் ஒரே மாதிரியானவை மற்றும் உங்கள் மொழிபெயர்ப்பு கோப்புகளுக்கான கீகளாக செயல்படுகின்றன. உண்மையான காட்சி ஸ்ட்ரிங்குகள் பின்னர் ஒரு i18n லைப்ரரியில் இருந்து (எ.கா., react-i18next, vue-i18n, FormatJS) பயனரின் தேர்ந்தெடுக்கப்பட்ட மொழியின் அடிப்படையில் பெறப்படுகின்றன.

            // app/features/product/constants.ts
export const ProductCategories = {
  ELECTRONICS: "ELECTRONICS",
  APPAREL: "APPAREL",
  HOME_GOODS: "HOME_GOODS",
  BOOKS: "BOOKS",
} as const;

export type ProductCategory = typeof ProductCategories[keyof typeof ProductCategories];

// app/i18n/locales/en.json
{
  "productCategories": {
    "ELECTRONICS": "Electronics",
    "APPAREL": "Apparel & Accessories",
    "HOME_GOODS": "Home Goods",
    "BOOKS": "Books"
  }
}

// app/i18n/locales/es.json
{
  "productCategories": {
    "ELECTRONICS": "Electrónica",
    "APPAREL": "Ropa y Accesorios",
    "HOME_GOODS": "Artículos para el hogar",
    "BOOKS": "Libros"
  }
}

// app/components/ProductCategorySelector.tsx
import { ProductCategories, type ProductCategory } from "../features/product/constants";
import { useTranslation } from "react-i18next";

function ProductCategorySelector() {
  const { t } = useTranslation();

  return (
    <select>
      {Object.values(ProductCategories).map(categoryKey => (
        <option key={categoryKey} value={categoryKey}>
          {t(`productCategories.${categoryKey}`)}
        </option>
      ))}
    </select>
  );
}

            

              
                Copy
              
            
          

இந்த கவலைகளின் பிரிப்பு, ஸ்கேலபிள், உலகளாவிய அப்ளிகேஷன்களுக்கு மிக முக்கியம். டைப்ஸ்கிரிப்ட் டைப்கள் நீங்கள் எப்போதும் சரியான கீகளைப் பயன்படுத்துகிறீர்கள் என்பதை உறுதிசெய்கின்றன, மேலும் i18n சிஸ்டம் பயனரின் லோகேலை அடிப்படையாகக் கொண்டு பிரசன்டேஷன் லேயரைக் கையாள்கிறது. இது மொழி சார்ந்த ஸ்ட்ரிங்குகளை உங்கள் கோர் அப்ளிகேஷன் லாஜிக்கில் நேரடியாக உட்பொதிப்பதைத் தவிர்க்கிறது, இது சர்வதேச அணிகளுக்கு ஒரு பொதுவான ஆண்டி-பேட்டர்ன் ஆகும்.

முடிவுரை: உங்கள் டைப்ஸ்கிரிப்ட் வடிவமைப்புத் தேர்வுகளுக்கு அதிகாரம் அளித்தல்

டைப்ஸ்கிரிப்ட் தொடர்ந்து வளர்ச்சியடைந்து, உலகெங்கிலும் உள்ள டெவலப்பர்களுக்கு மிகவும் வலுவான மற்றும் ஸ்கேலபிள் அப்ளிகேஷன்களை உருவாக்க அதிகாரம் அளிக்கும்போது, அதன் நுணுக்கமான அம்சங்களையும் மாற்றுகளையும் புரிந்துகொள்வது மேலும் முக்கியமாகிறது. டைப்ஸ்கிரிப்டின் enum முக்கிய சொல் பெயரிடப்பட்ட மாறிலிகளை வரையறுக்க ஒரு வசதியான வழியை வழங்கினாலும், அதன் ரன்டைம் அடிச்சுவடு, ட்ரீ-ஷேக்கிங் வரம்புகள் மற்றும் ரிவர்ஸ் மேப்பிங் சிக்கல்கள் பெரும்பாலும் நவீன மாற்றுகளை செயல்திறன்-உணர்திறன் கொண்ட அல்லது பெரிய அளவிலான திட்டங்களுக்கு மிகவும் கவர்ச்சிகரமானதாக ஆக்குகின்றன.

ஸ்ட்ரிங்/நியூமரிக் லிட்டரல்ஸ் கொண்ட யூனியன் டைப்கள் மிகவும் மெலிந்த மற்றும் கம்பைல்-டைம்-மையப்படுத்தப்பட்ட தீர்வாக தனித்து நிற்கின்றன. அவை ரன்டைமில் எந்த ஜாவாஸ்கிரிப்ட் குறியீட்டையும் உருவாக்காமல் சமரசமற்ற டைப் பாதுகாப்பை வழங்குகின்றன, இது குறைந்தபட்ச தொகுப்பு அளவு மற்றும் அதிகபட்ச ட்ரீ-ஷேக்கிங் முன்னுரிமைகளாக இருக்கும் சூழ்நிலைகளுக்கும், ரன்டைம் எண்ணிக்கை ஒரு கவலையாக இல்லாத சூழ்நிலைகளுக்கும் அவற்றை சிறந்ததாக ஆக்குகிறது.

மறுபுறம், கான்ஸ்ட் அசர்ட்ஷன்ஸ் (as const) உடன் typeof மற்றும் keyof இணைந்து ஒரு மிகவும் நெகிழ்வான மற்றும் சக்திவாய்ந்த முறையை வழங்குகின்றன. அவை உங்கள் மாறிலிகளுக்கு ஒரு ஒற்றை மூல உண்மையை, வலுவான கம்பைல்-டைம் டைப் பாதுகாப்பை, மற்றும் ரன்டைமில் மதிப்புகளை மறுசெயல்பாடு செய்யக்கூடிய முக்கியமான திறனை வழங்குகின்றன. உங்கள் மாறிலிகளுடன் கூடுதல் டேட்டாவை தொடர்புபடுத்த வேண்டிய, டைனமிக் UI களை நிரப்ப வேண்டிய, அல்லது சர்வதேசமயமாக்கல் அமைப்புகளுடன் தடையின்றி ஒருங்கிணைக்க வேண்டிய சூழ்நிலைகளுக்கு இந்த அணுகுமுறை குறிப்பாக ஏற்றது.

வர்த்தக பரிமாற்றங்களை – ரன்டைம் அடிச்சுவடு, மறுசெயல்பாடு தேவைகள் மற்றும் தொடர்புடைய டேட்டாவின் சிக்கல்தன்மை – கவனமாக கருத்தில் கொள்வதன் மூலம், சுத்தமான, மிகவும் திறமையான மற்றும் பராமரிக்கக்கூடிய டைப்ஸ்கிரிப்ட் குறியீட்டிற்கு வழிவகுக்கும் தகவலறிந்த முடிவுகளை நீங்கள் எடுக்கலாம். இந்த மாற்றுகளை ஏற்றுக்கொள்வது "நவீன" டைப்ஸ்கிரிப்டை எழுதுவது மட்டுமல்ல; இது உங்கள் அப்ளிகேஷனின் செயல்திறன், டெவலப்பர் அனுபவம் மற்றும் உலகளாவிய பார்வையாளர்களுக்கான நீண்ட கால நிலைத்தன்மையை மேம்படுத்தும் வேண்டுமென்றே கட்டடக்கலை தேர்வுகளைப் பற்றியது.

சரியான வேலைக்கு சரியான கருவியைத் தேர்ந்தெடுப்பதன் மூலம் உங்கள் டைப்ஸ்கிரிப்ட் மேம்பாட்டிற்கு அதிகாரம் அளியுங்கள், சிறந்த மாற்றுகள் இருக்கும்போது இயல்புநிலை ஈனமிற்கு அப்பால் செல்லுங்கள்.